// import { postApi, uploadImage } from '../../../utils/api'; // 直接导入uploadImage函数
const api = require('../../../utils/api'); // 使用CommonJS方式导入全部API
const system = require('../../../utils/system.js'); // 添加system引用

Page({
  /**
   * 页面的初始数据
   */
  data: {
    selectedType: 'question',
    title: '', // 帖子标题
    content: '', // 帖子内容
    images: [], // 帖子图片
    canSubmit: false, // 是否可以提交
    typeMap: {
      'question': '提问',
      'share': '分享',
      'discuss': '讨论'
    },
    submitting: false, // 是否正在提交
    statusBarHeight: 0, // 状态栏高度
    navBarHeight: 0, // 导航栏高度
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    // 获取状态栏高度
    const systemInfo = wx.getSystemInfoSync();
    this.setData({
      statusBarHeight: systemInfo.statusBarHeight || 20,
      navBarHeight: 44 // 固定导航栏高度
    });
    
    // 如果有传入默认类型，则设置
    if (options.type && this.data.typeMap[options.type]) {
      this.setData({
        selectedType: options.type
      });
    }
  },

  /**
   * 选择帖子类型
   */
  selectType(e) {
    const type = e.currentTarget.dataset.type;
    this.setData({
      selectedType: type
    });
    this.checkCanSubmit();
  },

  /**
   * 标题输入事件
   */
  onTitleInput(e) {
    this.setData({
      title: e.detail.value
    }, this.checkCanSubmit);
  },

  /**
   * 内容输入事件
   */
  onContentInput(e) {
    this.setData({
      content: e.detail.value
    }, this.checkCanSubmit);
  },

  /**
   * 检查是否可以提交
   */
  checkCanSubmit() {
    const { title, content, submitting } = this.data;
    
    // 如果正在提交，不允许再次提交
    if (submitting) {
      return false;
    }
    
    // 标题和内容不能为空
    const canSubmit = title.trim() !== '' && content.trim() !== '';
    
    // 更新状态
    if (this.data.canSubmit !== canSubmit) {
      this.setData({ canSubmit });
    }
    
    // 如果不能提交，显示提示
    if (!canSubmit) {
      wx.showToast({
        title: '标题和内容不能为空',
        icon: 'none'
      });
    }
    
    return canSubmit;
  },

  /**
   * 选择图片
   */
  async chooseImage() {
    const res = await wx.chooseImage({
      count: 9 - this.data.images.length,
      sizeType: ['compressed'],
      sourceType: ['album', 'camera']
    });

    this.setData({
      images: [...this.data.images, ...res.tempFilePaths]
    });
  },

  /**
   * 删除图片
   */
  deleteImage(e) {
    const { index } = e.currentTarget.dataset;
    const images = [...this.data.images];
    images.splice(index, 1);
    this.setData({ images });
  },

  /**
   * 预览图片
   */
  previewImage(e) {
    const { current } = e.currentTarget.dataset;
    wx.previewImage({
      current,
      urls: this.data.images
    });
  },

  /**
   * 取消发帖
   */
  cancelPost() {
    // 如果有输入内容，弹出确认框
    if (this.data.title || this.data.content || this.data.images.length > 0) {
      wx.showModal({
        title: '提示',
        content: '是否放弃编辑？',
        confirmText: '放弃',
        confirmColor: '#ff4d4f',
        success: (res) => {
          if (res.confirm) {
            wx.navigateBack();
          }
        }
      });
    } else {
      wx.navigateBack();
    }
  },

  /**
   * 提交帖子
   */
  async submitPost() {
    console.log('准备提交帖子');
    if (!this.checkCanSubmit()) {
      console.error('表单验证失败');
      return;
    }

    try {
      this.setData({ submitting: true });
      wx.showLoading({ 
        title: '处理中...',
        mask: true 
      });
      
      const token = wx.getStorageSync('token');
      if (!token) {
        wx.hideLoading();
        wx.showToast({
          title: '请先登录',
          icon: 'none'
        });
        setTimeout(() => {
          wx.navigateTo({ url: '/pages/login/index' });
        }, 1500);
        return;
      }

      // 先上传所有图片
      const imageUrls = [];
      console.log('待上传的图片数量:', this.data.images.length);
      
      if (this.data.images.length > 0) {
        wx.showLoading({ 
          title: '正在上传图片...',
          mask: true 
        });
        
        try {
          // 并行上传所有图片
          const uploadPromises = this.data.images.map(path => api.uploadImage(path));
          const uploadResults = await Promise.all(uploadPromises);
          
          console.log('所有图片上传结果:', uploadResults);
          
          // 过滤掉无效的URL
          uploadResults.forEach(url => {
            if (url && typeof url === 'string') {
              imageUrls.push(url);
            }
          });
          
          console.log('成功上传的图片URLs:', imageUrls);
          
          // 检查是否所有图片都成功上传
          if (imageUrls.length !== this.data.images.length) {
            console.warn(`部分图片上传失败: 预期${this.data.images.length}张，实际上传成功${imageUrls.length}张`);
            // 询问用户是否继续
            const confirmContinue = await new Promise(resolve => {
              wx.hideLoading();
              wx.showModal({
                title: '提示',
                content: '部分图片上传失败，是否继续发布？',
                confirmText: '继续发布',
                cancelText: '取消',
                success: res => resolve(res.confirm)
              });
            });
            
            if (!confirmContinue) {
              wx.hideLoading();
              this.setData({ submitting: false });
              return;
            }
          }
        } catch (error) {
          console.error('图片上传出错:', error);
          wx.hideLoading();
          wx.showToast({
            title: '图片上传失败',
            icon: 'none'
          });
          this.setData({ submitting: false });
          return;
        }
      }

      // 准备帖子数据
      const postData = {
        title: this.data.title.trim(),
        content: this.data.content.trim(),
        type: this.data.selectedType,
        images: imageUrls
      };
      
      console.log('准备提交的帖子数据:', postData);

      // 提交帖子
      wx.showLoading({ 
        title: '发布中...',
        mask: true 
      });
      
      try {
        const result = await api.publishPost(postData);
        wx.hideLoading();
        
        console.log('帖子提交结果:', result);
        
        // 检查result是否有效
        if (result && (result.code === 200 || (result.images && result.images.length > 0))) {
          wx.showToast({
            title: '发布成功',
            icon: 'success'
          });
          
          // 缓存发布成功的帖子，以便快速显示
          if (result.data) {
            wx.setStorageSync('last_published_post', {
              ...result.data,
              createTime: new Date().toISOString()
            });
          }
          
          // 延迟后返回论坛页面
          setTimeout(() => {
            wx.navigateBack();
          }, 1500);
        } else {
          console.error('发布帖子失败:', result);
          wx.showToast({
            title: result.message || '发布失败，请重试',
            icon: 'none'
          });
        }
      } catch (error) {
        console.error('发布帖子请求出错:', error);
        wx.hideLoading();
        wx.showToast({
          title: error.message || '网络请求失败',
          icon: 'none'
        });
      }
    } catch (error) {
      console.error('发布帖子过程中出错:', error);
      wx.hideLoading();
      wx.showToast({
        title: '发布失败，请重试',
        icon: 'none'
      });
    } finally {
      this.setData({ submitting: false });
    }
  },

  // 返回上一页
  goBack() {
    wx.navigateBack({
      delta: 1
    });
  },
  
  // 上传文件
  uploadFile(filePath, retryCount = 0) {
    console.log('开始上传文件:', filePath);
    if (!filePath) {
      console.error('文件路径无效');
      return Promise.reject('文件路径无效');
    }

    return new Promise((resolve, reject) => {
      const token = wx.getStorageSync('token');
      if (!token) {
        console.error('用户未登录，无法上传文件');
        reject('请先登录');
        return;
      }

      // 从app.js获取BASE_URL
      const app = getApp();
      // 确保包含api前缀
      let BASE_URL = app.globalData.baseUrl || 'http://localhost:8080';
      if (!BASE_URL.endsWith('/api')) {
        BASE_URL = `${BASE_URL}/api`;
      }
      console.log('使用的BASE_URL:', BASE_URL);

      // 检查文件是否存在
      wx.getFileInfo({
        filePath,
        success: (fileInfo) => {
          console.log('文件信息:', fileInfo);
          // 文件存在，继续上传
          sendUploadRequest();
        },
        fail: (err) => {
          console.error('获取文件信息失败，文件可能不存在:', err);
          reject('文件不存在或无法访问');
        }
      });

      // 执行上传请求
      const sendUploadRequest = () => {
        wx.uploadFile({
          url: `${BASE_URL}/file/upload`,
          filePath,
          name: 'file',
          header: {
            'Authorization': token
          },
          success: (res) => {
            try {
              console.log('文件上传成功，原始响应:', res);
              
              // 如果res.data是字符串，需要解析为JSON
              let result;
              try {
                result = typeof res.data === 'string' ? JSON.parse(res.data) : res.data;
              } catch (e) {
                console.error('解析上传响应JSON失败:', e);
                
                // 尝试重试
                if (retryCount < 2) {
                  console.log(`上传解析失败，第${retryCount + 1}次重试`);
                  setTimeout(() => {
                    this.uploadFile(filePath, retryCount + 1)
                      .then(url => resolve(url))
                      .catch(error => reject(error));
                  }, 1000);
                  return;
                }
                
                reject('响应格式错误');
                return;
              }
              console.log('解析后的响应数据:', result);
              
              if (result.code !== 200) {
                console.error('上传失败，服务器返回错误:', result.message || '未知错误');
                
                // 服务器错误时尝试重试
                if (retryCount < 2) {
                  console.log(`服务器返回错误，第${retryCount + 1}次重试`);
                  setTimeout(() => {
                    this.uploadFile(filePath, retryCount + 1)
                      .then(url => resolve(url))
                      .catch(error => reject(error));
                  }, 1000);
                  return;
                }
                
                reject(result.message || '上传失败');
                return;
              }
              
              let url = result.data;
              // 可能需要从不同的路径获取URL
              if (!url && result.data && typeof result.data === 'object') {
                url = result.data.url || result.data.path || '';
              }
              console.log('服务器返回的原始URL:', url);
              
              // 确保URL是完整的
              if (typeof url === 'string' && !url.startsWith('http')) {
                // 确保使用正确的URL格式，uploads前不应该有/api
                const baseUrlWithoutApi = BASE_URL.replace(/\/api$/, '');
                url = `${baseUrlWithoutApi}${url.startsWith('/') ? '' : '/'}${url}`;
                console.log('转换为完整URL:', url);
              }
              
              // 验证URL是否可访问（仅限于图片）
              if (url && url.match(/\.(jpg|jpeg|png|gif|webp)$/i)) {
                wx.getImageInfo({
                  src: url,
                  success: () => {
                    console.log('图片URL可以访问:', url);
                    resolve(url);
                  },
                  fail: (err) => {
                    console.warn('图片URL无法访问，但仍然返回:', url, err);
                    resolve(url); // 仍然返回URL，因为可能是网络问题
                  }
                });
              } else {
                console.log('最终处理的图片URL:', url);
                resolve(url);
              }
            } catch (e) {
              console.error('处理上传响应失败:', e, res);
              
              // 尝试重试
              if (retryCount < 2) {
                console.log(`处理响应出错，第${retryCount + 1}次重试`);
                setTimeout(() => {
                  this.uploadFile(filePath, retryCount + 1)
                    .then(url => resolve(url))
                    .catch(error => reject(error));
                }, 1000);
                return;
              }
              
              reject('处理上传响应失败');
            }
          },
          fail: (err) => {
            console.error('文件上传请求失败:', err);
            
            // 网络错误时尝试重试
            if (retryCount < 2) {
              console.log(`上传请求失败，第${retryCount + 1}次重试`);
              setTimeout(() => {
                this.uploadFile(filePath, retryCount + 1)
                  .then(url => resolve(url))
                  .catch(error => reject(error));
              }, 1000);
            } else {
              reject('上传失败');
            }
          }
        });
      };
    });
  }
}); 